home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-desktop-9.10-i386-PL.iso / casper / filesystem.squashfs / usr / share / hplip / base / device.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2009-10-28  |  65KB  |  2,063 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import socket
  5. import re
  6. import gzip
  7. import os.path as os
  8. import time
  9. import urllib
  10. import StringIO
  11. import httplib
  12. import struct
  13. from g import *
  14. from codes import *
  15. import utils
  16. import status
  17. import pml
  18. from prnt import pcl, ldl, cups
  19. import models
  20. import mdns
  21. import slp
  22. from strings import StringTable
  23.  
  24. try:
  25.     import hpmudext
  26. except ImportError:
  27.     if not os.getenv('HPLIP_BUILD'):
  28.         log.error('HPMUDEXT could not be loaded. Please check HPLIP installation.')
  29.         sys.exit(1)
  30.     
  31. except:
  32.     not os.getenv('HPLIP_BUILD')
  33.  
  34.  
  35. try:
  36.     MAX_BUFFER = hpmudext.HPMUD_BUFFER_SIZE
  37. except AttributeError:
  38.     MAX_BUFFER = 8192
  39.  
  40. dbus_avail = False
  41. dbus_disabled = False
  42.  
  43. try:
  44.     import dbus
  45.     from dbus import lowlevel, SessionBus
  46.     dbus_avail = True
  47. except ImportError:
  48.     log.warn('python-dbus not installed.')
  49.  
  50. import warnings
  51. warnings.simplefilter('ignore', DeprecationWarning)
  52. DEFAULT_PROBE_BUS = [
  53.     'usb',
  54.     'par',
  55.     'cups']
  56. VALID_BUSES = ('par', 'net', 'cups', 'usb')
  57. VALID_BUSES_WO_CUPS = ('par', 'net', 'usb')
  58. DEFAULT_FILTER = None
  59. VALID_FILTERS = ('print', 'scan', 'fax', 'pcard', 'copy')
  60. DEFAULT_BE_FILTER = ('hp',)
  61. pat_deviceuri = re.compile('(.*):/(.*?)/(\\S*?)\\?(?:serial=(\\S*)|device=(\\S*)|ip=(\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}[^&]*)|zc=(\\S+))(?:&port=(\\d))?', re.IGNORECASE)
  62. http_pat_url = re.compile('/(.*?)/(\\S*?)\\?(?:serial=(\\S*)|device=(\\S*))&loc=(\\S*)', re.IGNORECASE)
  63. direct_pat = re.compile('direct (.*?) "(.*?)" "(.*?)" "(.*?)"', re.IGNORECASE)
  64. pat_dynamic_ctr = re.compile('CTR:\\d*\\s.*;', re.IGNORECASE)
  65. model_dat = models.ModelData()
  66. ip_pat = re.compile('\\b(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\b', re.IGNORECASE)
  67. dev_pat = re.compile('/dev/.+', re.IGNORECASE)
  68. usb_pat = re.compile('(\\d+):(\\d+)', re.IGNORECASE)
  69.  
  70. class Event(object):
  71.     
  72.     def __init__(self, device_uri, printer_name, event_code, username = prop.username, job_id = 0, title = '', timedate = 0):
  73.         self.device_uri = unicode(utils.xrstrip(device_uri, '\x00'))[:64].encode('utf-8')
  74.         self.printer_name = unicode(utils.xrstrip(printer_name, '\x00'))[:64].encode('utf-8')
  75.         self.event_code = int(event_code)
  76.         self.username = unicode(utils.xrstrip(username, '\x00'))[:32].encode('utf-8')
  77.         self.job_id = int(job_id)
  78.         self.title = unicode(utils.xrstrip(title, '\x00'))[:64].encode('utf-8')
  79.         if timedate:
  80.             self.timedate = float(timedate)
  81.         else:
  82.             self.timedate = time.time()
  83.         self.pipe_fmt = '64s64sI32sI64sf'
  84.         self.dbus_fmt = 'ssisisd'
  85.  
  86.     
  87.     def debug(self):
  88.         log.debug('    device_uri=%s' % self.device_uri)
  89.         log.debug('    printer_name=%s' % self.printer_name)
  90.         log.debug('    event_code=%d' % self.event_code)
  91.         log.debug('    username=%s' % self.username)
  92.         log.debug('    job_id=%d' % self.job_id)
  93.         log.debug('    title=%s' % self.title)
  94.         log.debug('    timedate=%s' % self.timedate)
  95.  
  96.     
  97.     def pack_for_pipe(self):
  98.         return struct.pack(self.pipe_fmt, self.device_uri, self.printer_name, self.event_code, self.username, self.job_id, self.title, self.timedate)
  99.  
  100.     
  101.     def send_via_pipe(self, fd, recipient = 'hpssd'):
  102.         if fd is not None:
  103.             log.debug('Sending event %d to %s (via pipe %d)...' % (self.event_code, recipient, fd))
  104.             
  105.             try:
  106.                 os.write(fd, self.pack_for_pipe())
  107.                 return True
  108.             except OSError:
  109.                 log.debug('Failed.')
  110.                 return False
  111.             
  112.  
  113.         None<EXCEPTION MATCH>OSError
  114.  
  115.     
  116.     def send_via_dbus(self, session_bus, interface = 'com.hplip.StatusService'):
  117.         if session_bus is not None and dbus_avail:
  118.             log.debug('Sending event %d to %s (via dbus)...' % (self.event_code, interface))
  119.             msg = lowlevel.SignalMessage('/', interface, 'Event')
  120.             msg.append(signature = self.dbus_fmt, *self.as_tuple())
  121.             session_bus.send_message(msg)
  122.         
  123.  
  124.     
  125.     def copy(self):
  126.         return Event(*self.as_tuple())
  127.  
  128.     
  129.     def __str__(self):
  130.         return "<Event('%s', '%s', %d, '%s', %d, '%s', %f)>" % self.as_tuple()
  131.  
  132.     
  133.     def as_tuple(self):
  134.         return (self.device_uri, self.printer_name, self.event_code, self.username, self.job_id, self.title, self.timedate)
  135.  
  136.  
  137.  
  138. class FaxEvent(Event):
  139.     
  140.     def __init__(self, temp_file, event):
  141.         Event.__init__(self, *event.as_tuple())
  142.         self.temp_file = temp_file
  143.         self.pipe_fmt = '64s64sI32sI64sfs'
  144.         self.dbus_fmt = 'ssisisfs'
  145.  
  146.     
  147.     def debug(self):
  148.         log.debug('FAX:')
  149.         Event.debug(self)
  150.         log.debug('    temp_file=%s' % self.temp_file)
  151.  
  152.     
  153.     def __str__(self):
  154.         return "<FaxEvent('%s', '%s', %d, '%s', %d, '%s', %f, '%s')>" % self.as_tuple()
  155.  
  156.     
  157.     def as_tuple(self):
  158.         return (self.device_uri, self.printer_name, self.event_code, self.username, self.job_id, self.title, self.timedate, self.temp_file)
  159.  
  160.  
  161.  
  162. class DeviceIOEvent(Event):
  163.     
  164.     def __init__(self, bytes_written, event):
  165.         Event.__init__(self, *event.as_tuple())
  166.         self.bytes_written = bytes_written
  167.         self.pipe_fmt = '64s64sI32sI64sfI'
  168.         self.dbus_fmt = 'ssisisfi'
  169.  
  170.     
  171.     def debug(self):
  172.         log.debug('DEVIO:')
  173.         Event.debug(self)
  174.         log.debug('    bytes_written=%d' % self.bytes_written)
  175.  
  176.     
  177.     def __str__(self):
  178.         return "<DeviceIOEvent('%s', '%s', %d, '%s', %d, '%s', %f, '%d')>" % self.as_tuple()
  179.  
  180.     
  181.     def as_tuple(self):
  182.         return (self.device_uri, self.printer_name, self.event_code, self.username, self.job_id, self.title, self.timedate, self.bytes_written)
  183.  
  184.  
  185.  
  186. def init_dbus(dbus_loop = None):
  187.     global dbus_avail
  188.     service = None
  189.     session_bus = None
  190.     os.getuid() == 0 if not prop.gui_build else os.getuid() == 0
  191.     return (dbus_avail, service, session_bus)
  192.  
  193.  
  194. def makeURI(param, port = 1):
  195.     (cups_uri, sane_uri, fax_uri) = ('', '', '')
  196.     found = False
  197.     if dev_pat.search(param) is not None:
  198.         log.debug('Trying parallel with %s' % param)
  199.         (result_code, uri) = hpmudext.make_par_uri(param)
  200.         if result_code == hpmudext.HPMUD_R_OK and uri:
  201.             log.debug('Found: %s' % uri)
  202.             found = True
  203.             cups_uri = uri
  204.         else:
  205.             log.debug('Not found.')
  206.     elif usb_pat.search(param) is not None:
  207.         match_obj = usb_pat.search(param)
  208.         usb_bus_id = match_obj.group(1)
  209.         usb_dev_id = match_obj.group(2)
  210.         log.debug('Trying USB with bus=%s dev=%s...' % (usb_bus_id, usb_dev_id))
  211.         (result_code, uri) = hpmudext.make_usb_uri(usb_bus_id, usb_dev_id)
  212.         if result_code == ERROR_SUCCESS and uri:
  213.             log.debug('Found: %s' % uri)
  214.             found = True
  215.             cups_uri = uri
  216.         else:
  217.             log.debug('Not found.')
  218.     elif ip_pat.search(param) is not None:
  219.         log.debug('Trying IP address %s' % param)
  220.         (result_code, uri) = hpmudext.make_net_uri(param, port)
  221.         if result_code == hpmudext.HPMUD_R_OK and uri:
  222.             log.debug('Found: %s' % uri)
  223.             found = True
  224.             cups_uri = uri
  225.         else:
  226.             log.debug('Not found.')
  227.     else:
  228.         log.debug('Trying ZC hostname %s' % param)
  229.         (result_code, uri) = hpmudext.make_zc_uri(param, port)
  230.         if result_code == hpmudext.HPMUD_R_OK and uri:
  231.             log.debug('Found: %s' % uri)
  232.             found = True
  233.             cups_uri = uri
  234.         else:
  235.             log.debug('Not found.')
  236.     if not found:
  237.         log.debug('Trying serial number %s' % param)
  238.         devices = probeDevices(bus = [
  239.             'usb',
  240.             'par'])
  241.         for d in devices:
  242.             log.debug(d)
  243.             
  244.             try:
  245.                 (back_end, is_hp, bus, model, serial, dev_file, host, zc, port) = parseDeviceURI(d)
  246.             except Error:
  247.                 continue
  248.  
  249.             if bus == 'par':
  250.                 mq = queryModelByURI(d)
  251.                 (result_code, device_id) = hpmudext.device_open(d, mq.get('io-mode', hpmudext.HPMUD_UNI_MODE))
  252.                 if result_code == hpmudext.HPMUD_R_OK:
  253.                     (result_code, data) = hpmudext.get_device_id(device_id)
  254.                     serial = parseDeviceID(data).get('SN', '')
  255.                     hpmudext.close_device(device_id)
  256.                 
  257.             
  258.             if serial.lower() == param.lower():
  259.                 log.debug('Found: %s' % d)
  260.                 found = True
  261.                 cups_uri = d
  262.                 break
  263.                 continue
  264.             log.debug('Not found.')
  265.         
  266.     
  267.     if found:
  268.         
  269.         try:
  270.             mq = queryModelByURI(cups_uri)
  271.         except Error:
  272.             e = None
  273.             log.error('Error: %s' % e.msg)
  274.             (cups_uri, sane_uri, fax_uri) = ('', '', '')
  275.  
  276.         if mq.get('support-type', SUPPORT_TYPE_NONE) > SUPPORT_TYPE_NONE:
  277.             if mq.get('scan-type', 0):
  278.                 sane_uri = cups_uri.replace('hp:', 'hpaio:')
  279.             
  280.             if mq.get('fax-type', 0):
  281.                 fax_uri = cups_uri.replace('hp:', 'hpfax:')
  282.             
  283.         else:
  284.             (cups_uri, sane_uri, fax_uri) = ('', '', '')
  285.     else:
  286.         (scan_uri, fax_uri) = ('', '')
  287.     if cups_uri:
  288.         user_conf.set('last_used', 'device_uri', cups_uri)
  289.     
  290.     return (cups_uri, sane_uri, fax_uri)
  291.  
  292.  
  293. def queryModelByModel(model):
  294.     model = models.normalizeModelName(model).lower()
  295.     return model_dat[model]
  296.  
  297.  
  298. def queryModelByURI(device_uri):
  299.     
  300.     try:
  301.         (back_end, is_hp, bus, model, serial, dev_file, host, zc, port) = parseDeviceURI(device_uri)
  302.     except Error:
  303.         raise Error(ERROR_INVALID_DEVICE_URI)
  304.  
  305.     return queryModelByModel(model)
  306.  
  307.  
  308. def probeDevices(bus = DEFAULT_PROBE_BUS, timeout = 10, ttl = 4, filter = DEFAULT_FILTER, search = '', net_search = 'mdns', back_end_filter = ('hp',)):
  309.     num_devices = 0
  310.     ret_devices = { }
  311.     if search:
  312.         
  313.         try:
  314.             search_pat = re.compile(search, re.IGNORECASE)
  315.         log.error('Invalid search pattern. Search uses standard regular expressions. For more info, see: http://www.amk.ca/python/howto/regex/')
  316.         search = ''
  317.  
  318.     
  319.     for b in bus:
  320.         log.debug('Probing bus: %s' % b)
  321.         if b not in VALID_BUSES:
  322.             log.error('Invalid bus: %s' % b)
  323.             continue
  324.         
  325.         None if b == 'net' else result_code == hpmudext.HPMUD_R_OK
  326.         if b == 'cups':
  327.             cups_printers = cups.getPrinters()
  328.             x = len(cups_printers)
  329.             for p in cups_printers:
  330.                 device_uri = p.device_uri
  331.                 log.debug('%s: %s' % (device_uri, p.name))
  332.                 if device_uri != '':
  333.                     
  334.                     try:
  335.                         (back_end, is_hp, bs, model, serial, dev_file, host, zc, port) = parseDeviceURI(device_uri)
  336.                     except Error:
  337.                         log.debug('Unrecognized URI: %s' % device_uri)
  338.                         continue
  339.  
  340.                     if not is_hp:
  341.                         continue
  342.                     
  343.                     include = True
  344.                     mq = queryModelByModel(model)
  345.                     if not mq:
  346.                         include = False
  347.                         log.debug('Not found.')
  348.                     elif int(mq.get('support-type', SUPPORT_TYPE_NONE)) == SUPPORT_TYPE_NONE:
  349.                         log.debug('Not supported.')
  350.                         include = False
  351.                     elif filter not in (None, 'print', 'print-type'):
  352.                         include = __checkFilter(filter, mq)
  353.                     
  354.                     if include:
  355.                         ret_devices[device_uri] = (model, model, '')
  356.                     
  357.                 include
  358.             
  359.     
  360.     probed_devices = { }
  361.     for uri in ret_devices:
  362.         num_devices += 1
  363.         (mdl, model, devid_or_hn) = ret_devices[uri]
  364.         include = True
  365.         if search:
  366.             match_obj = search_pat.search('%s %s %s %s' % (mdl, model, devid_or_hn, uri))
  367.             if match_obj is None:
  368.                 log.debug("%s %s %s %s: Does not match search '%s'." % (mdl, model, devid_or_hn, uri, search))
  369.                 include = False
  370.             
  371.         
  372.         if include:
  373.             probed_devices[uri] = ret_devices[uri]
  374.             continue
  375.     
  376.     cleanup_spinner()
  377.     return probed_devices
  378.  
  379.  
  380. def getSupportedCUPSDevices(back_end_filter = [
  381.     'hp'], filter = DEFAULT_FILTER):
  382.     devices = { }
  383.     printers = cups.getPrinters()
  384.     for p in printers:
  385.         
  386.         try:
  387.             (back_end, is_hp, bus, model, serial, dev_file, host, zc, port) = parseDeviceURI(p.device_uri)
  388.         except Error:
  389.             continue
  390.  
  391.         if (back_end_filter == '*' and back_end in back_end_filter or 'hpaio' in back_end_filter or back_end == 'hp') and model and is_hp:
  392.             include = True
  393.             mq = queryModelByModel(model)
  394.             if not mq:
  395.                 log.debug('Not found.')
  396.                 include = False
  397.             elif int(mq.get('support-type', SUPPORT_TYPE_NONE)) == SUPPORT_TYPE_NONE:
  398.                 log.debug('Not supported.')
  399.                 include = False
  400.             elif filter not in (None, 'print', 'print-type'):
  401.                 include = __checkFilter(filter, mq)
  402.             
  403.             if include:
  404.                 if 'hpaio' in back_end_filter:
  405.                     d = p.device_uri.replace('hp:', 'hpaio:')
  406.                 else:
  407.                     d = p.device_uri
  408.                 
  409.                 try:
  410.                     devices[d]
  411.                 except KeyError:
  412.                     devices[d] = [
  413.                         p.name]
  414.  
  415.                 devices[d].append(p.name)
  416.             
  417.         include
  418.     
  419.     return devices
  420.  
  421.  
  422. def getSupportedCUPSPrinters(back_end_filter = [
  423.     'hp'], filter = DEFAULT_FILTER):
  424.     printer_list = []
  425.     printers = cups.getPrinters()
  426.     for p in printers:
  427.         
  428.         try:
  429.             (back_end, is_hp, bus, model, serial, dev_file, host, zc, port) = parseDeviceURI(p.device_uri)
  430.         except Error:
  431.             continue
  432.  
  433.         if (back_end_filter == '*' or back_end in back_end_filter) and model and is_hp:
  434.             include = True
  435.             mq = queryModelByModel(model)
  436.             if not mq:
  437.                 log.debug('Not found.')
  438.                 include = False
  439.             elif int(mq.get('support-type', SUPPORT_TYPE_NONE)) == SUPPORT_TYPE_NONE:
  440.                 log.debug('Not supported.')
  441.                 include = False
  442.             elif filter not in (None, 'print', 'print-type'):
  443.                 include = __checkFilter(filter, mq)
  444.             
  445.             if include:
  446.                 p.name = p.name.decode('utf-8')
  447.                 printer_list.append(p)
  448.             
  449.         include
  450.     
  451.     return printer_list
  452.  
  453.  
  454. def getSupportedCUPSPrinterNames(back_end_filter = [
  455.     'hp'], filter = DEFAULT_FILTER):
  456.     printers = getSupportedCUPSPrinters(back_end_filter, filter)
  457.     return [ p.name for p in printers ]
  458.  
  459.  
  460. def getDeviceURIByPrinterName(printer_name, scan_uri_flag = False):
  461.     if printer_name is None:
  462.         return None
  463.     device_uri = None
  464.     printers = cups.getPrinters()
  465.     for p in printers:
  466.         
  467.         try:
  468.             (back_end, is_hp, bus, model, serial, dev_file, host, zc, port) = parseDeviceURI(p.device_uri)
  469.         except Error:
  470.             printer_name is None
  471.             printer_name is None
  472.             continue
  473.         except:
  474.             printer_name is None
  475.  
  476.         if is_hp and p.name == printer_name:
  477.             if scan_uri_flag:
  478.                 device_uri = p.device_uri.replace('hp:', 'hpaio:')
  479.             else:
  480.                 device_uri = p.device_uri
  481.             break
  482.             continue
  483.     
  484.     return device_uri
  485.  
  486.  
  487. def parseDeviceID(device_id):
  488.     d = { }
  489.     x = _[1]
  490.     for z in x:
  491.         y = z.split(':')
  492.         
  493.         try:
  494.             d.setdefault(y[0].strip(), y[1])
  495.         continue
  496.         except IndexError:
  497.             []
  498.             []
  499.             []
  500.             d.setdefault(y[0].strip(), None)
  501.             continue
  502.         
  503.  
  504.     
  505.     d.setdefault('MDL', '')
  506.     d.setdefault('SN', '')
  507.     if 'SERIAL' in d:
  508.         d['SN'] = d['SERIAL']
  509.         del d['SERIAL']
  510.     elif 'SERN' in d:
  511.         d['SN'] = d['SERN']
  512.         del d['SERN']
  513.     
  514.     if d['SN'].startswith('X'):
  515.         d['SN'] = ''
  516.     
  517.     return d
  518.  
  519.  
  520. def parseDynamicCounter(ctr_field, convert_to_int = True):
  521.     (counter, value) = ctr_field.split(' ')
  522.     
  523.     try:
  524.         if not utils.xlstrip(str(counter), '0'):
  525.             pass
  526.         counter = int('0')
  527.         if convert_to_int:
  528.             if not utils.xlstrip(str(value), '0'):
  529.                 pass
  530.             value = int('0')
  531.     except ValueError:
  532.         if convert_to_int:
  533.             (counter, value) = (0, 0)
  534.         else:
  535.             (counter, value) = (0, '')
  536.     except:
  537.         convert_to_int
  538.  
  539.     return (counter, value)
  540.  
  541.  
  542. def parseDeviceURI(device_uri):
  543.     m = pat_deviceuri.match(device_uri)
  544.     if m is None:
  545.         log.debug('Device URI %s is invalid/unknown' % device_uri)
  546.         raise Error(ERROR_INVALID_DEVICE_URI)
  547.     m is None
  548.     if not m.group(1).lower():
  549.         pass
  550.     back_end = ''
  551.     is_hp = back_end in ('hp', 'hpfax', 'hpaio')
  552.     if not m.group(2).lower():
  553.         pass
  554.     bus = ''
  555.     if bus not in ('usb', 'net', 'bt', 'fw', 'par'):
  556.         log.debug('Device URI %s is invalid/unknown' % device_uri)
  557.         raise Error(ERROR_INVALID_DEVICE_URI)
  558.     bus not in ('usb', 'net', 'bt', 'fw', 'par')
  559.     if not m.group(3):
  560.         pass
  561.     model = ''
  562.     if not m.group(4):
  563.         pass
  564.     serial = ''
  565.     if not m.group(5):
  566.         pass
  567.     dev_file = ''
  568.     if not m.group(6):
  569.         pass
  570.     host = ''
  571.     zc = ''
  572.     if not host:
  573.         if not m.group(7):
  574.             pass
  575.         zc = host = ''
  576.     
  577.     if not m.group(8):
  578.         pass
  579.     port = 1
  580.     if bus == 'net':
  581.         
  582.         try:
  583.             port = int(port)
  584.         except (ValueError, TypeError):
  585.             port = 1
  586.  
  587.         if port == 0:
  588.             port = 1
  589.         
  590.     
  591.     log.debug('%s: back_end:%s is_hp:%s bus:%s model:%s serial:%s dev_file:%s host:%s zc:%s port:%s' % (device_uri, back_end, is_hp, bus, model, serial, dev_file, host, zc, port))
  592.     return (back_end, is_hp, bus, model, serial, dev_file, host, zc, port)
  593.  
  594.  
  595. def isLocal(bus):
  596.     return bus in ('par', 'usb', 'fw', 'bt')
  597.  
  598.  
  599. def isNetwork(bus):
  600.     return bus in ('net',)
  601.  
  602.  
  603. def __checkFilter(filter, mq):
  604.     for f, p in filter.items():
  605.         if f is not None:
  606.             (op, val) = p
  607.             if not op(mq[f], val):
  608.                 return False
  609.             continue
  610.         op(mq[f], val)
  611.     
  612.     return True
  613.  
  614.  
  615. def validateBusList(bus, allow_cups = True):
  616.     for b in bus:
  617.         if allow_cups:
  618.             vb = VALID_BUSES
  619.         else:
  620.             vb = VALID_BUSES_WO_CUPS
  621.         if b not in vb:
  622.             log.error('Invalid bus name: %s' % b)
  623.             return False
  624.     
  625.     return True
  626.  
  627.  
  628. def validateFilterList(filter):
  629.     if filter is None:
  630.         return True
  631.     for f in filter:
  632.         if f not in VALID_FILTERS:
  633.             log.error("Invalid term '%s' in filter list" % f)
  634.             return False
  635.     
  636.     return True
  637.  
  638. inter_pat = re.compile('%(.*)%', re.IGNORECASE)
  639. st = StringTable()
  640. strings_init = False
  641.  
  642. def initStrings():
  643.     global strings_init
  644.     strings_init = True
  645.     cycles = 0
  646.     while True:
  647.         found = False
  648.         for s in st.string_table:
  649.             (short_string, long_string) = st.string_table[s]
  650.             short_replace = short_string
  651.             long_replace = long_string
  652.             
  653.             try:
  654.                 short_match = inter_pat.match(short_string).group(1)
  655.             except (AttributeError, TypeError):
  656.                 short_match = None
  657.  
  658.             if short_match is not None:
  659.                 found = True
  660.                 
  661.                 try:
  662.                     (short_replace, dummy) = st.string_table[short_match]
  663.                 except KeyError:
  664.                     log.error('String interpolation error: %s' % short_match)
  665.                 except:
  666.                     None<EXCEPTION MATCH>KeyError
  667.                 
  668.  
  669.             None<EXCEPTION MATCH>KeyError
  670.             
  671.             try:
  672.                 long_match = inter_pat.match(long_string).group(1)
  673.             except (AttributeError, TypeError):
  674.                 long_match = None
  675.  
  676.             if long_match is not None:
  677.                 found = True
  678.                 
  679.                 try:
  680.                     (dummy, long_replace) = st.string_table[long_match]
  681.                 except KeyError:
  682.                     log.error('String interpolation error: %s' % long_match)
  683.                 except:
  684.                     None<EXCEPTION MATCH>KeyError
  685.                 
  686.  
  687.             None<EXCEPTION MATCH>KeyError
  688.             if found:
  689.                 st.string_table[s] = (short_replace, long_replace)
  690.                 continue
  691.         
  692.         if not found:
  693.             break
  694.             continue
  695.         cycles += 1
  696.         if cycles > 1000:
  697.             break
  698.             continue
  699.  
  700.  
  701. def queryString(string_id, typ = 0):
  702.     if not strings_init:
  703.         initStrings()
  704.     
  705.     s = st.string_table.get(str(string_id), ('', ''))[typ]
  706.     if type(s) == type(''):
  707.         return s
  708.     return s()
  709.  
  710. AGENT_types = {
  711.     AGENT_TYPE_NONE: 'invalid',
  712.     AGENT_TYPE_BLACK: 'black',
  713.     AGENT_TYPE_CMY: 'cmy',
  714.     AGENT_TYPE_KCM: 'kcm',
  715.     AGENT_TYPE_CYAN: 'cyan',
  716.     AGENT_TYPE_MAGENTA: 'magenta',
  717.     AGENT_TYPE_YELLOW: 'yellow',
  718.     AGENT_TYPE_CYAN_LOW: 'photo_cyan',
  719.     AGENT_TYPE_MAGENTA_LOW: 'photo_magenta',
  720.     AGENT_TYPE_YELLOW_LOW: 'photo_yellow',
  721.     AGENT_TYPE_GGK: 'photo_gray',
  722.     AGENT_TYPE_BLUE: 'photo_blue',
  723.     AGENT_TYPE_KCMY_CM: 'kcmy_cm',
  724.     AGENT_TYPE_LC_LM: 'photo_cyan_and_photo_magenta',
  725.     AGENT_TYPE_LG_PK: 'light_gray_and_photo_black',
  726.     AGENT_TYPE_LG: 'light_gray',
  727.     AGENT_TYPE_G: 'medium_gray',
  728.     AGENT_TYPE_PG: 'photo_gray',
  729.     AGENT_TYPE_C_M: 'cyan_and_magenta',
  730.     AGENT_TYPE_K_Y: 'black_and_yellow',
  731.     AGENT_TYPE_UNSPECIFIED: 'unspecified' }
  732. AGENT_kinds = {
  733.     AGENT_KIND_NONE: 'invalid',
  734.     AGENT_KIND_HEAD: 'head',
  735.     AGENT_KIND_SUPPLY: 'supply',
  736.     AGENT_KIND_HEAD_AND_SUPPLY: 'cartridge',
  737.     AGENT_KIND_TONER_CARTRIDGE: 'toner',
  738.     AGENT_KIND_MAINT_KIT: 'maint_kit',
  739.     AGENT_KIND_ADF_KIT: 'adf_kit',
  740.     AGENT_KIND_DRUM_KIT: 'drum_kit',
  741.     AGENT_KIND_TRANSFER_KIT: 'transfer_kit',
  742.     AGENT_KIND_INT_BATTERY: 'battery',
  743.     AGENT_KIND_UNKNOWN: 'unknown' }
  744. AGENT_healths = {
  745.     AGENT_HEALTH_OK: 'ok',
  746.     AGENT_HEALTH_MISINSTALLED: 'misinstalled',
  747.     AGENT_HEALTH_INCORRECT: 'incorrect',
  748.     AGENT_HEALTH_FAILED: 'failed',
  749.     AGENT_HEALTH_OVERTEMP: 'overtemp',
  750.     AGENT_HEALTH_CHARGING: 'charging',
  751.     AGENT_HEALTH_DISCHARGING: 'discharging' }
  752. AGENT_levels = {
  753.     AGENT_LEVEL_TRIGGER_MAY_BE_LOW: 'low',
  754.     AGENT_LEVEL_TRIGGER_PROBABLY_OUT: 'low',
  755.     AGENT_LEVEL_TRIGGER_ALMOST_DEFINITELY_OUT: 'out' }
  756. string_cache = { }
  757.  
  758. class Device(object):
  759.     
  760.     def __init__(self, device_uri, printer_name = None, service = None, callback = None, disable_dbus = False):
  761.         global dbus_disabled
  762.         log.debug('Device URI: %s' % device_uri)
  763.         log.debug('Printer: %s' % printer_name)
  764.         dbus_disabled = disable_dbus
  765.         if not disable_dbus:
  766.             if service is None:
  767.                 (self.dbus_avail, self.service, session_bus) = init_dbus()
  768.             else:
  769.                 self.dbus_avail = True
  770.                 self.service = service
  771.         else:
  772.             self.dbus_avail = False
  773.             self.service = None
  774.         self.last_event = None
  775.         printers = cups.getPrinters()
  776.         if device_uri is None and printer_name is not None:
  777.             for p in printers:
  778.                 if p.name.lower() == printer_name.lower():
  779.                     device_uri = p.device_uri
  780.                     log.debug('Device URI: %s' % device_uri)
  781.                     break
  782.                     continue
  783.             else:
  784.                 raise Error(ERROR_DEVICE_NOT_FOUND)
  785.         self.device_uri = device_uri
  786.         self.callback = callback
  787.         self.device_type = DEVICE_TYPE_UNKNOWN
  788.         if self.device_uri is None:
  789.             raise Error(ERROR_DEVICE_NOT_FOUND)
  790.         self.device_uri is None
  791.         if self.device_uri.startswith('hp:'):
  792.             self.device_type = DEVICE_TYPE_PRINTER
  793.         elif self.device_uri.startswith('hpaio:'):
  794.             self.device_type = DEVICE_TYPE_SCANNER
  795.         elif self.device_uri.startswith('hpfax:'):
  796.             self.device_type = DEVICE_TYPE_FAX
  797.         
  798.         
  799.         try:
  800.             (self.back_end, self.is_hp, self.bus, self.model, self.serial, self.dev_file, self.host, self.zc, self.port) = parseDeviceURI(self.device_uri)
  801.         except Error:
  802.             self.io_state = IO_STATE_NON_HP
  803.             raise Error(ERROR_INVALID_DEVICE_URI)
  804.  
  805.         log.debug('URI: backend=%s, is_hp=%s, bus=%s, model=%s, serial=%s, dev=%s, host=%s, port=%d' % (self.back_end, self.is_hp, self.bus, self.model, self.serial, self.dev_file, self.host, self.port))
  806.         self.model_ui = models.normalizeModelUIName(self.model)
  807.         self.model = models.normalizeModelName(self.model)
  808.         log.debug('Model/UI model: %s/%s' % (self.model, self.model_ui))
  809.         self.mq = { }
  810.         self.dq = { }
  811.         self.icon = 'default_printer'
  812.         self.cups_printers = []
  813.         self.channels = { }
  814.         self.device_id = -1
  815.         self.r_values = None
  816.         self.deviceID = ''
  817.         self.panel_check = True
  818.         self.io_state = IO_STATE_HP_READY
  819.         self.is_local = isLocal(self.bus)
  820.         self.hist = []
  821.         self.supported = False
  822.         self.queryModel()
  823.         if not self.supported:
  824.             log.error('Unsupported model: %s' % self.model)
  825.             self.error_code = STATUS_DEVICE_UNSUPPORTED
  826.             self.sendEvent(self.error_code)
  827.         else:
  828.             self.supported = True
  829.         self.mq.update({
  830.             'model': self.model,
  831.             'model-ui': self.model_ui })
  832.         self.error_state = ERROR_STATE_ERROR
  833.         self.device_state = DEVICE_STATE_NOT_FOUND
  834.         self.status_code = EVENT_ERROR_DEVICE_NOT_FOUND
  835.         self.updateCUPSPrinters()
  836.         if self.mq.get('fax-type', FAX_TYPE_NONE) != FAX_TYPE_NONE:
  837.             self.dq.update({
  838.                 'fax-uri': self.device_uri.replace('hp:/', 'hpfax:/').replace('hpaio:/', 'hpfax:/') })
  839.         
  840.         if self.mq.get('scan-type', SCAN_TYPE_NONE) != SCAN_TYPE_NONE:
  841.             self.dq.update({
  842.                 'scan-uri': self.device_uri.replace('hp:/', 'hpaio:/').replace('hpfax:/', 'hpaio:/') })
  843.         
  844.         self.dq.update({
  845.             'back-end': self.back_end,
  846.             'is-hp': self.is_hp,
  847.             'serial': self.serial,
  848.             'dev-file': self.dev_file,
  849.             'host': self.host,
  850.             'port': self.port,
  851.             'cups-printers': ','.join(self.cups_printers),
  852.             'status-code': self.status_code,
  853.             'status-desc': '',
  854.             'deviceid': '',
  855.             'panel': 0,
  856.             'panel-line1': '',
  857.             'panel-line2': '',
  858.             'device-state': self.device_state,
  859.             'error-state': self.error_state,
  860.             'device-uri': self.device_uri,
  861.             'cups-uri': self.device_uri.replace('hpfax:/', 'hp:/').replace('hpaio:/', 'hp:/') })
  862.         self.device_vars = {
  863.             'URI': self.device_uri,
  864.             'DEVICE_URI': self.device_uri,
  865.             'SCAN_URI': self.device_uri.replace('hp:', 'hpaio:'),
  866.             'SANE_URI': self.device_uri.replace('hp:', 'hpaio:'),
  867.             'FAX_URI': self.device_uri.replace('hp:', 'hpfax:'),
  868.             'PRINTER': self.first_cups_printer,
  869.             'HOME': prop.home_dir }
  870.  
  871.     
  872.     def sendEvent(self, event_code, printer_name = '', job_id = 0, title = ''):
  873.         if self.dbus_avail and self.service is not None:
  874.             
  875.             try:
  876.                 log.debug('Sending event %d to hpssd...' % event_code)
  877.                 self.service.SendEvent(self.device_uri, printer_name, event_code, prop.username, job_id, title)
  878.             except dbus.exceptions.DBusException:
  879.                 e = None
  880.                 log.debug('dbus call to SendEvent() failed.')
  881.             except:
  882.                 None<EXCEPTION MATCH>dbus.exceptions.DBusException
  883.             
  884.  
  885.         None<EXCEPTION MATCH>dbus.exceptions.DBusException
  886.  
  887.     
  888.     def quit(self):
  889.         pass
  890.  
  891.     
  892.     def queryModel(self):
  893.         if not self.mq:
  894.             self.mq = queryModelByURI(self.device_uri)
  895.         
  896.         self.supported = bool(self.mq)
  897.         if self.supported:
  898.             for m in self.mq:
  899.                 self.__dict__[m.replace('-', '_')] = self.mq[m]
  900.             
  901.         
  902.  
  903.     
  904.     def queryString(self, string_id):
  905.         return queryString(string_id)
  906.  
  907.     
  908.     def open(self, open_for_printing = False):
  909.         if self.supported and self.io_state in (IO_STATE_HP_READY, IO_STATE_HP_NOT_AVAIL):
  910.             prev_device_state = self.device_state
  911.             self.io_state = IO_STATE_HP_NOT_AVAIL
  912.             self.device_state = DEVICE_STATE_NOT_FOUND
  913.             self.error_state = ERROR_STATE_ERROR
  914.             self.status_code = EVENT_ERROR_DEVICE_NOT_FOUND
  915.             self.device_id = -1
  916.             self.open_for_printing = open_for_printing
  917.             if open_for_printing:
  918.                 log.debug('Opening device: %s (for printing)' % self.device_uri)
  919.                 self.io_mode = self.mq.get('io-mode', hpmudext.HPMUD_UNI_MODE)
  920.             else:
  921.                 log.debug('Opening device: %s (not for printing)' % self.device_uri)
  922.                 self.io_mode = self.mq.get('io-mfp-mode', hpmudext.HPMUD_UNI_MODE)
  923.             log.debug('I/O mode=%d' % self.io_mode)
  924.             (result_code, self.device_id) = hpmudext.open_device(self.device_uri, self.io_mode)
  925.             if result_code != hpmudext.HPMUD_R_OK:
  926.                 self.error_state = ERROR_STATE_ERROR
  927.                 self.error_code = result_code + ERROR_CODE_BASE
  928.                 self.sendEvent(self.error_code)
  929.                 if result_code == hpmudext.HPMUD_R_DEVICE_BUSY:
  930.                     log.error('Device busy: %s' % self.device_uri)
  931.                 else:
  932.                     log.error('Unable to communicate with device (code=%d): %s' % (result_code, self.device_uri))
  933.                 self.last_event = Event(self.device_uri, '', EVENT_ERROR_DEVICE_NOT_FOUND, prop.username, 0, '', time.time())
  934.                 raise Error(ERROR_DEVICE_NOT_FOUND)
  935.             result_code != hpmudext.HPMUD_R_OK
  936.             log.debug('device-id=%d' % self.device_id)
  937.             self.io_state = IO_STATE_HP_OPEN
  938.             self.error_state = ERROR_STATE_CLEAR
  939.             log.debug('Opened device: %s (backend=%s, is_hp=%s, bus=%s, model=%s, dev=%s, serial=%s, host=%s, port=%d)' % (self.back_end, self.device_uri, self.is_hp, self.bus, self.model, self.dev_file, self.serial, self.host, self.port))
  940.             if prev_device_state == DEVICE_STATE_NOT_FOUND:
  941.                 self.device_state = DEVICE_STATE_JUST_FOUND
  942.             else:
  943.                 self.device_state = DEVICE_STATE_FOUND
  944.             self.getDeviceID()
  945.             self.getSerialNumber()
  946.             return self.device_id
  947.         self.io_state in (IO_STATE_HP_READY, IO_STATE_HP_NOT_AVAIL)
  948.  
  949.     
  950.     def close(self):
  951.         if self.io_state == IO_STATE_HP_OPEN:
  952.             log.debug('Closing device...')
  953.             if len(self.channels) > 0:
  954.                 for c in self.channels.keys():
  955.                     self._Device__closeChannel(c)
  956.                 
  957.             
  958.             result_code = hpmudext.close_device(self.device_id)
  959.             log.debug('Result-code = %d' % result_code)
  960.             self.channels.clear()
  961.             self.io_state = IO_STATE_HP_READY
  962.         
  963.  
  964.     
  965.     def __openChannel(self, service_name):
  966.         
  967.         try:
  968.             if self.io_state == IO_STATE_HP_OPEN:
  969.                 if service_name == hpmudext.HPMUD_S_PRINT_CHANNEL and not (self.open_for_printing):
  970.                     self.close()
  971.                     self.open(True)
  972.                 elif service_name != hpmudext.HPMUD_S_PRINT_CHANNEL and self.open_for_printing:
  973.                     self.close()
  974.                     self.open(False)
  975.                 
  976.             else:
  977.                 self.open(service_name == hpmudext.HPMUD_S_PRINT_CHANNEL)
  978.         except:
  979.             log.error('unable to open channel')
  980.             return -1
  981.  
  982.         service_name = service_name.upper()
  983.         if service_name not in self.channels:
  984.             log.debug('Opening %s channel...' % service_name)
  985.             (result_code, channel_id) = hpmudext.open_channel(self.device_id, service_name)
  986.             self.channels[service_name] = channel_id
  987.             log.debug('channel-id=%d' % channel_id)
  988.             return channel_id
  989.         return self.channels[service_name]
  990.  
  991.     
  992.     def openChannel(self, service_name):
  993.         return self._Device__openChannel(service_name)
  994.  
  995.     
  996.     def openPrint(self):
  997.         return self._Device__openChannel(hpmudext.HPMUD_S_PRINT_CHANNEL)
  998.  
  999.     
  1000.     def openFax(self):
  1001.         return self._Device__openChannel(hpmudext.HPMUD_S_FAX_SEND_CHANNEL)
  1002.  
  1003.     
  1004.     def openPCard(self):
  1005.         return self._Device__openChannel(hpmudext.HPMUD_S_MEMORY_CARD_CHANNEL)
  1006.  
  1007.     
  1008.     def openEWS(self):
  1009.         return self._Device__openChannel(hpmudext.HPMUD_S_EWS_CHANNEL)
  1010.  
  1011.     
  1012.     def closePrint(self):
  1013.         return self._Device__closeChannel(hpmudext.HPMUD_S_PRINT_CHANNEL)
  1014.  
  1015.     
  1016.     def closePCard(self):
  1017.         return self._Device__closeChannel(hpmudext.HPMUD_S_MEMORY_CARD_CHANNEL)
  1018.  
  1019.     
  1020.     def closeFax(self):
  1021.         return self._Device__closeChannel(hpmudext.HPMUD_S_FAX_SEND_CHANNEL)
  1022.  
  1023.     
  1024.     def openPML(self):
  1025.         return self._Device__openChannel(hpmudext.HPMUD_S_PML_CHANNEL)
  1026.  
  1027.     
  1028.     def openWifiConfig(self):
  1029.         return self._Device__openChannel(hpmudext.HPMUD_S_WIFI_CHANNEL)
  1030.  
  1031.     
  1032.     def closePML(self):
  1033.         return self._Device__closeChannel(hpmudext.HPMUD_S_PML_CHANNEL)
  1034.  
  1035.     
  1036.     def closeEWS(self):
  1037.         return self._Device__closeChannel(hpmudext.HPMUD_S_EWS_CHANNEL)
  1038.  
  1039.     
  1040.     def openCfgUpload(self):
  1041.         return self._Device__openChannel(hpmudext.HPMUD_S_CONFIG_UPLOAD_CHANNEL)
  1042.  
  1043.     
  1044.     def closeCfgUpload(self):
  1045.         return self._Device__closeChannel(hpmudext.HPMUD_S_CONFIG_UPLOAD_CHANNEL)
  1046.  
  1047.     
  1048.     def openCfgDownload(self):
  1049.         return self._Device__openChannel(hpmudext.HPMUD_S_CONFIG_DOWNLOAD_CHANNEL)
  1050.  
  1051.     
  1052.     def closeCfgDownload(self):
  1053.         return self._Device__closeChannel(hpmudext.HPMUD_S_CONFIG_DOWNLOAD_CHANNEL)
  1054.  
  1055.     
  1056.     def openSoapFax(self):
  1057.         return self._Device__openChannel(hpmudext.HPMUD_S_SOAP_FAX)
  1058.  
  1059.     
  1060.     def closeSoapFax(self):
  1061.         return self._Device__closeChannel(hpmudext.HPMUD_S_SOAP_FAX)
  1062.  
  1063.     
  1064.     def closeWifiConfig(self):
  1065.         return self._Device__closeChannel(hpmudext.HPMUD_S_WIFI_CHANNEL)
  1066.  
  1067.     
  1068.     def __closeChannel(self, service_name):
  1069.         if self.io_state == IO_STATE_HP_OPEN:
  1070.             service_name = service_name.upper()
  1071.             if service_name in self.channels:
  1072.                 log.debug('Closing %s channel...' % service_name)
  1073.                 result_code = hpmudext.close_channel(self.device_id, self.channels[service_name])
  1074.                 del self.channels[service_name]
  1075.             
  1076.         
  1077.  
  1078.     
  1079.     def closeChannel(self, service_name):
  1080.         return self._Device__closeChannel(service_name)
  1081.  
  1082.     
  1083.     def getDeviceID(self):
  1084.         needs_close = False
  1085.         if self.io_state != IO_STATE_HP_OPEN:
  1086.             
  1087.             try:
  1088.                 self.open()
  1089.             except:
  1090.                 return -1
  1091.  
  1092.             needs_close = True
  1093.         
  1094.         (result_code, data) = hpmudext.get_device_id(self.device_id)
  1095.         if result_code != hpmudext.HPMUD_R_OK:
  1096.             self.raw_deviceID = ''
  1097.             self.deviceID = { }
  1098.         else:
  1099.             self.raw_deviceID = data
  1100.             self.deviceID = parseDeviceID(data)
  1101.         if needs_close:
  1102.             self.close()
  1103.         
  1104.         return self.deviceID
  1105.  
  1106.     
  1107.     def getSerialNumber(self):
  1108.         if self.serial:
  1109.             return None
  1110.         
  1111.         try:
  1112.             self.serial = self.deviceID['SN']
  1113.         except KeyError:
  1114.             self.serial
  1115.             self.serial
  1116.         except:
  1117.             self.serial
  1118.  
  1119.         if self.serial:
  1120.             return None
  1121.         if self.serial is None:
  1122.             self.serial = ''
  1123.         
  1124.  
  1125.     
  1126.     def getThreeBitStatus(self):
  1127.         pass
  1128.  
  1129.     
  1130.     def getStatusFromDeviceID(self):
  1131.         self.getDeviceID()
  1132.         return status.parseStatus(parseDeviceID(self.raw_deviceID))
  1133.  
  1134.     
  1135.     def __parseRValues(self, r_value):
  1136.         r_value_str = str(r_value)
  1137.         r_value_str = ''.join([
  1138.             '0' * (9 - len(r_value_str)),
  1139.             r_value_str])
  1140.         rg = r_value_str[:3]
  1141.         rr = r_value_str[3:]
  1142.         r_value = int(rr)
  1143.         self.r_values = (r_value, r_value_str, rg, rr)
  1144.         return (r_value, r_value_str, rg, rr)
  1145.  
  1146.     
  1147.     def getRValues(self, r_type, status_type, dynamic_counters):
  1148.         (r_value, r_value_str, rg, rr) = (0, '000000000', '000', '000000')
  1149.         if r_type > 0 and dynamic_counters != STATUS_DYNAMIC_COUNTERS_NONE:
  1150.             if self.r_values is None:
  1151.                 if self.dbus_avail:
  1152.                     
  1153.                     try:
  1154.                         r_value = int(self.service.GetCachedIntValue(self.device_uri, 'r_value'))
  1155.                     except dbus.exceptions.DBusException:
  1156.                         e = None
  1157.                         log.debug('dbus call to GetCachedIntValue() failed.')
  1158.                         r_value = -1
  1159.                     except:
  1160.                         None<EXCEPTION MATCH>dbus.exceptions.DBusException
  1161.                     
  1162.  
  1163.                 None<EXCEPTION MATCH>dbus.exceptions.DBusException
  1164.                 if r_value != -1:
  1165.                     log.debug('r_value=%d' % r_value)
  1166.                     (r_value, r_value_str, rg, rr) = self._Device__parseRValues(r_value)
  1167.                     return (r_value, r_value_str, rg, rr)
  1168.             
  1169.             if self.r_values is None:
  1170.                 if status_type == STATUS_TYPE_S and self.is_local and dynamic_counters != STATUS_DYNAMIC_COUNTERS_PML_SNMP:
  1171.                     
  1172.                     try:
  1173.                         r_value = self.getDynamicCounter(140)
  1174.                         if r_value is not None:
  1175.                             log.debug('r_value=%d' % r_value)
  1176.                             (r_value, r_value_str, rg, rr) = self._Device__parseRValues(r_value)
  1177.                             if self.dbus_avail:
  1178.                                 
  1179.                                 try:
  1180.                                     self.service.SetCachedIntValue(self.device_uri, 'r_value', r_value)
  1181.                                 except dbus.exceptions.DBusException:
  1182.                                     e = None
  1183.                                     log.debug('dbus call to SetCachedIntValue() failed.')
  1184.                                 except:
  1185.                                     None<EXCEPTION MATCH>dbus.exceptions.DBusException
  1186.                                 
  1187.  
  1188.                             None<EXCEPTION MATCH>dbus.exceptions.DBusException
  1189.                         else:
  1190.                             log.error('Error attempting to read r-value (2).')
  1191.                             r_value = 0
  1192.                     except Error:
  1193.                         log.error('Error attempting to read r-value (1).')
  1194.                         r_value = 0
  1195.                     finally:
  1196.                         self.closePrint()
  1197.  
  1198.                 elif status_type == STATUS_TYPE_S and dynamic_counters == STATUS_DYNAMIC_COUNTERS_PCL or not (self.is_local) or dynamic_counters == STATUS_DYNAMIC_COUNTERS_PML_SNMP:
  1199.                     
  1200.                     try:
  1201.                         (result_code, r_value) = self.getPML(pml.OID_R_SETTING)
  1202.                         if r_value is not None:
  1203.                             log.debug('r_value=%d' % r_value)
  1204.                             (r_value, r_value_str, rg, rr) = self._Device__parseRValues(r_value)
  1205.                             if self.dbus_avail:
  1206.                                 
  1207.                                 try:
  1208.                                     self.service.SetCachedIntValue(self.device_uri, 'r_value', r_value)
  1209.                                 except dbus.exceptions.DBusException:
  1210.                                     e = None
  1211.                                     log.debug('dbus call to SetCachedIntValue() failed.')
  1212.                                 except:
  1213.                                     None<EXCEPTION MATCH>dbus.exceptions.DBusException
  1214.                                 
  1215.  
  1216.                             None<EXCEPTION MATCH>dbus.exceptions.DBusException
  1217.                         else:
  1218.                             r_value = 0
  1219.                     finally:
  1220.                         self.closePML()
  1221.  
  1222.                 
  1223.             else:
  1224.                 (r_value, r_value_str, rg, rr) = self.r_values
  1225.         
  1226.         return (r_value, r_value_str, rg, rr)
  1227.  
  1228.     
  1229.     def __queryFax(self, quick = False, reread_cups_printers = False):
  1230.         io_mode = self.mq.get('io-mode', IO_MODE_UNI)
  1231.         self.status_code = STATUS_PRINTER_IDLE
  1232.         if io_mode != IO_MODE_UNI:
  1233.             if self.device_state != DEVICE_STATE_NOT_FOUND:
  1234.                 if self.tech_type in (TECH_TYPE_MONO_INK, TECH_TYPE_COLOR_INK):
  1235.                     
  1236.                     try:
  1237.                         self.getDeviceID()
  1238.                     except Error:
  1239.                         e = None
  1240.                         log.error('Error getting device ID.')
  1241.                         self.last_event = Event(self.device_uri, '', ERROR_DEVICE_IO_ERROR, prop.username, 0, '', time.time())
  1242.                         raise Error(ERROR_DEVICE_IO_ERROR)
  1243.                     except:
  1244.                         None<EXCEPTION MATCH>Error
  1245.                     
  1246.  
  1247.                 None<EXCEPTION MATCH>Error
  1248.                 status_desc = self.queryString(self.status_code)
  1249.                 self.dq.update({
  1250.                     'serial': self.serial,
  1251.                     'cups-printers': ','.join(self.cups_printers),
  1252.                     'status-code': self.status_code,
  1253.                     'status-desc': status_desc,
  1254.                     'deviceid': self.raw_deviceID,
  1255.                     'panel': 0,
  1256.                     'panel-line1': '',
  1257.                     'panel-line2': '',
  1258.                     'device-state': self.device_state,
  1259.                     'error-state': self.error_state })
  1260.             
  1261.             log.debug('Fax activity check...')
  1262.             (tx_active, rx_active) = status.getFaxStatus(self)
  1263.             if tx_active:
  1264.                 self.status_code = STATUS_FAX_TX_ACTIVE
  1265.             elif rx_active:
  1266.                 self.status_code = STATUS_FAX_RX_ACTIVE
  1267.             
  1268.             self.error_state = STATUS_TO_ERROR_STATE_MAP.get(self.status_code, ERROR_STATE_CLEAR)
  1269.             self.error_code = self.status_code
  1270.             self.sendEvent(self.error_code)
  1271.             
  1272.             try:
  1273.                 self.dq.update({
  1274.                     'status-desc': self.queryString(self.status_code),
  1275.                     'error-state': self.error_state })
  1276.             except (KeyError, Error):
  1277.                 self.dq.update({
  1278.                     'status-desc': '',
  1279.                     'error-state': ERROR_STATE_CLEAR })
  1280.  
  1281.             if self.panel_check:
  1282.                 self.panel_check = bool(self.mq.get('panel-check-type', 0))
  1283.             
  1284.             status_type = self.mq.get('status-type', STATUS_TYPE_NONE)
  1285.             if self.panel_check and status_type in (STATUS_TYPE_LJ, STATUS_TYPE_S, STATUS_TYPE_VSTATUS) and io_mode != IO_MODE_UNI:
  1286.                 log.debug('Panel check...')
  1287.                 
  1288.                 try:
  1289.                     (self.panel_check, line1, line2) = status.PanelCheck(self)
  1290.                 finally:
  1291.                     self.closePML()
  1292.  
  1293.                 self.dq.update({
  1294.                     'panel': int(self.panel_check),
  1295.                     'panel-line1': line1,
  1296.                     'panel-line2': line2 })
  1297.             
  1298.             if not quick and reread_cups_printers:
  1299.                 self.updateCUPSPrinters()
  1300.             
  1301.         
  1302.         for d in self.dq:
  1303.             self.__dict__[d.replace('-', '_')] = self.dq[d]
  1304.         
  1305.         self.last_event = Event(self.device_uri, '', self.status_code, prop.username, 0, '', time.time())
  1306.         log.debug(self.dq)
  1307.  
  1308.     
  1309.     def updateCUPSPrinters(self):
  1310.         self.cups_printers = []
  1311.         log.debug('Re-reading CUPS printer queue information.')
  1312.         printers = cups.getPrinters()
  1313.         for p in printers:
  1314.             if self.device_uri == p.device_uri:
  1315.                 self.cups_printers.append(p.name)
  1316.                 self.state = p.state
  1317.                 if self.io_state == IO_STATE_NON_HP:
  1318.                     self.model = p.makemodel.split(',')[0]
  1319.                 
  1320.             self.io_state == IO_STATE_NON_HP
  1321.         
  1322.         self.dq.update({
  1323.             'cups-printers': ','.join(self.cups_printers) })
  1324.         
  1325.         try:
  1326.             self.first_cups_printer = self.cups_printers[0]
  1327.         except IndexError:
  1328.             self.first_cups_printer = ''
  1329.  
  1330.  
  1331.     
  1332.     def queryDevice(self, quick = False, reread_cups_printers = False):
  1333.         if not self.supported:
  1334.             self.dq = { }
  1335.             self.last_event = Event(self.device_uri, '', STATUS_DEVICE_UNSUPPORTED, prop.username, 0, '', time.time())
  1336.             return None
  1337.         if self.device_type == DEVICE_TYPE_FAX:
  1338.             return self._Device__queryFax(quick, reread_cups_printers)
  1339.         r_type = self.mq.get('r-type', 0)
  1340.         tech_type = self.mq.get('tech-type', TECH_TYPE_NONE)
  1341.         status_type = self.mq.get('status-type', STATUS_TYPE_NONE)
  1342.         battery_check = self.mq.get('status-battery-check', STATUS_BATTERY_CHECK_NONE)
  1343.         dynamic_counters = self.mq.get('status-dynamic-counters', STATUS_DYNAMIC_COUNTERS_NONE)
  1344.         io_mode = self.mq.get('io-mode', IO_MODE_UNI)
  1345.         io_mfp_mode = self.mq.get('io-mfp-mode', IO_MODE_UNI)
  1346.         status_code = STATUS_UNKNOWN
  1347.         agents = []
  1348.         if self.device_state != DEVICE_STATE_NOT_FOUND:
  1349.             if self.tech_type in (TECH_TYPE_MONO_INK, TECH_TYPE_COLOR_INK):
  1350.                 
  1351.                 try:
  1352.                     self.getDeviceID()
  1353.                 except Error:
  1354.                     self.device_type == DEVICE_TYPE_FAX
  1355.                     e = self.device_type == DEVICE_TYPE_FAX
  1356.                     self.supported
  1357.                     log.error('Error getting device ID.')
  1358.                     self.last_event = Event(self.device_uri, '', ERROR_DEVICE_IO_ERROR, prop.username, 0, '', time.time())
  1359.                     raise Error(ERROR_DEVICE_IO_ERROR)
  1360.                 except:
  1361.                     self.device_type == DEVICE_TYPE_FAX<EXCEPTION MATCH>Error
  1362.                 
  1363.  
  1364.             self.device_type == DEVICE_TYPE_FAX
  1365.             status_desc = self.queryString(self.status_code)
  1366.             self.dq.update({
  1367.                 'serial': self.serial,
  1368.                 'cups-printers': ','.join(self.cups_printers),
  1369.                 'status-code': self.status_code,
  1370.                 'status-desc': status_desc,
  1371.                 'deviceid': self.raw_deviceID,
  1372.                 'panel': 0,
  1373.                 'panel-line1': '',
  1374.                 'panel-line2': '',
  1375.                 'device-state': self.device_state,
  1376.                 'error-state': self.error_state })
  1377.             status_block = { }
  1378.             if status_type == STATUS_TYPE_NONE:
  1379.                 log.warn('No status available for device.')
  1380.                 status_block = {
  1381.                     'status-code': STATUS_UNKNOWN }
  1382.             elif status_type in (STATUS_TYPE_VSTATUS, STATUS_TYPE_S):
  1383.                 log.debug('Type 1/2 (S: or VSTATUS:) status')
  1384.                 status_block = status.parseStatus(self.deviceID)
  1385.             elif status_type in (STATUS_TYPE_LJ, STATUS_TYPE_PML_AND_PJL):
  1386.                 log.debug('Type 3/9 LaserJet PML(+PJL) status')
  1387.                 status_block = status.StatusType3(self, self.deviceID)
  1388.             elif status_type == STATUS_TYPE_LJ_XML:
  1389.                 log.debug('Type 6: LJ XML')
  1390.                 status_block = status.StatusType6(self)
  1391.             elif status_type == STATUS_TYPE_PJL:
  1392.                 log.debug('Type 8: LJ PJL')
  1393.                 status_block = status.StatusType8(self)
  1394.             else:
  1395.                 log.error('Unimplemented status type: %d' % status_type)
  1396.             if battery_check and io_mode != IO_MODE_UNI:
  1397.                 log.debug('Battery check...')
  1398.                 status.BatteryCheck(self, status_block, battery_check)
  1399.             
  1400.             if status_block:
  1401.                 log.debug(status_block)
  1402.                 self.dq.update(status_block)
  1403.                 
  1404.                 try:
  1405.                     status_block['agents']
  1406.                 except KeyError:
  1407.                     pass
  1408.  
  1409.                 agents = status_block['agents']
  1410.                 del self.dq['agents']
  1411.             
  1412.             status_code = self.dq.get('status-code', STATUS_UNKNOWN)
  1413.             self.error_state = STATUS_TO_ERROR_STATE_MAP.get(status_code, ERROR_STATE_CLEAR)
  1414.             self.error_code = status_code
  1415.             self.sendEvent(self.error_code)
  1416.             
  1417.             try:
  1418.                 self.dq.update({
  1419.                     'status-desc': self.queryString(status_code),
  1420.                     'error-state': self.error_state })
  1421.             except (KeyError, Error):
  1422.                 self.dq.update({
  1423.                     'status-desc': '',
  1424.                     'error-state': ERROR_STATE_CLEAR })
  1425.  
  1426.             r_value = 0
  1427.             if not quick and status_type != STATUS_TYPE_NONE:
  1428.                 if self.panel_check:
  1429.                     self.panel_check = bool(self.mq.get('panel-check-type', 0))
  1430.                 
  1431.                 if self.panel_check and status_type in (STATUS_TYPE_LJ, STATUS_TYPE_S, STATUS_TYPE_VSTATUS) and io_mode != IO_MODE_UNI:
  1432.                     log.debug('Panel check...')
  1433.                     
  1434.                     try:
  1435.                         (self.panel_check, line1, line2) = status.PanelCheck(self)
  1436.                     finally:
  1437.                         self.closePML()
  1438.  
  1439.                     self.dq.update({
  1440.                         'panel': int(self.panel_check),
  1441.                         'panel-line1': line1,
  1442.                         'panel-line2': line2 })
  1443.                 
  1444.                 if dynamic_counters != STATUS_DYNAMIC_COUNTERS_NONE and io_mode != IO_MODE_UNI:
  1445.                     (r_value, r_value_str, rg, rr) = self.getRValues(r_type, status_type, dynamic_counters)
  1446.                 else:
  1447.                     (r_value, r_value_str, rg, rr) = (0, '000000000', '000', '000000')
  1448.                 self.dq.update({
  1449.                     'r': r_value,
  1450.                     'rs': r_value_str,
  1451.                     'rg': rg,
  1452.                     'rr': rr })
  1453.             
  1454.             if not quick and reread_cups_printers:
  1455.                 self.updateCUPSPrinters()
  1456.             
  1457.             if not quick:
  1458.                 if r_value > 0 and self.mq.get('r%d-agent1-kind' % r_value, 0) == 0:
  1459.                     r_value = 0
  1460.                     self.dq.update({
  1461.                         'r': r_value,
  1462.                         'rs': r_value_str,
  1463.                         'rg': rg,
  1464.                         'rr': rr })
  1465.                 
  1466.                 (a, aa) = (1, 1)
  1467.                 while True:
  1468.                     mq_agent_kind = self.mq.get('r%d-agent%d-kind' % (r_value, a), -1)
  1469.                     if mq_agent_kind == -1:
  1470.                         break
  1471.                     
  1472.                     mq_agent_type = self.mq.get('r%d-agent%d-type' % (r_value, a), 0)
  1473.                     mq_agent_sku = self.mq.get('r%d-agent%d-sku' % (r_value, a), '')
  1474.                     found = False
  1475.                     log.debug('Looking for kind=%d, type=%d...' % (mq_agent_kind, mq_agent_type))
  1476.                     for agent in agents:
  1477.                         agent_kind = agent['kind']
  1478.                         agent_type = agent['type']
  1479.                         if agent_kind == mq_agent_kind and agent_type == mq_agent_type:
  1480.                             found = True
  1481.                             break
  1482.                             continue
  1483.                     
  1484.                     if found:
  1485.                         log.debug('found: r%d-kind%d-type%d' % (r_value, agent_kind, agent_type))
  1486.                         agent_health = agent.get('health', AGENT_HEALTH_OK)
  1487.                         agent_level = agent.get('level', 100)
  1488.                         agent_level_trigger = agent.get('level-trigger', AGENT_LEVEL_TRIGGER_SUFFICIENT_0)
  1489.                         log.debug('health=%d, level=%d, level_trigger=%d, status_code=%d' % (agent_health, agent_level, agent_level_trigger, status_code))
  1490.                         query = 'agent_%s_%s' % (AGENT_types.get(agent_type, 'unknown'), AGENT_kinds.get(agent_kind, 'unknown'))
  1491.                         agent_desc = self.queryString(query)
  1492.                         query = 'agent_health_ok'
  1493.                         if status_code == STATUS_PRINTER_IDLE or status_code == STATUS_PRINTER_OUT_OF_INK:
  1494.                             if (agent_health == AGENT_HEALTH_OK or agent_health == AGENT_HEALTH_FAIR_MODERATE or agent_kind == AGENT_KIND_HEAD) and agent_level_trigger >= AGENT_LEVEL_TRIGGER_MAY_BE_LOW:
  1495.                                 query = 'agent_level_%s' % AGENT_levels.get(agent_level_trigger, 'unknown')
  1496.                                 if tech_type in (TECH_TYPE_MONO_INK, TECH_TYPE_COLOR_INK):
  1497.                                     code = agent_type + STATUS_PRINTER_LOW_INK_BASE
  1498.                                 else:
  1499.                                     code = agent_type + STATUS_PRINTER_LOW_TONER_BASE
  1500.                                 self.dq['status-code'] = code
  1501.                                 self.dq['status-desc'] = self.queryString(code)
  1502.                                 self.dq['error-state'] = STATUS_TO_ERROR_STATE_MAP.get(code, ERROR_STATE_LOW_SUPPLIES)
  1503.                                 self.error_code = code
  1504.                                 self.sendEvent(self.error_code)
  1505.                                 if agent_level_trigger in (AGENT_LEVEL_TRIGGER_PROBABLY_OUT, AGENT_LEVEL_TRIGGER_ALMOST_DEFINITELY_OUT):
  1506.                                     query = 'agent_level_out'
  1507.                                 else:
  1508.                                     query = 'agent_level_low'
  1509.                                 agent_health_desc = self.queryString(query)
  1510.                                 self.dq.update({
  1511.                                     'agent%d-kind' % aa: agent_kind,
  1512.                                     'agent%d-type' % aa: agent_type,
  1513.                                     'agent%d-known' % aa: agent.get('known', False),
  1514.                                     'agent%d-sku' % aa: mq_agent_sku,
  1515.                                     'agent%d-level' % aa: agent_level,
  1516.                                     'agent%d-level-trigger' % aa: agent_level_trigger,
  1517.                                     'agent%d-ack' % aa: agent.get('ack', False),
  1518.                                     'agent%d-hp-ink' % aa: agent.get('hp-ink', False),
  1519.                                     'agent%d-health' % aa: agent_health,
  1520.                                     'agent%d-dvc' % aa: agent.get('dvc', 0),
  1521.                                     'agent%d-virgin' % aa: agent.get('virgin', False),
  1522.                                     'agent%d-desc' % aa: agent_desc,
  1523.                                     'agent%d-id' % aa: agent.get('id', 0),
  1524.                                     'agent%d-health-desc' % aa: agent_health_desc })
  1525.                             else:
  1526.                                 query = 'agent_health_%s' % AGENT_healths.get(agent_health, AGENT_HEALTH_OK)
  1527.                                 agent_health_desc = self.queryString(query)
  1528.                                 self.dq.update({
  1529.                                     'agent%d-kind' % aa: agent_kind,
  1530.                                     'agent%d-type' % aa: agent_type,
  1531.                                     'agent%d-known' % aa: False,
  1532.                                     'agent%d-sku' % aa: mq_agent_sku,
  1533.                                     'agent%d-level' % aa: agent_level,
  1534.                                     'agent%d-level-trigger' % aa: agent_level_trigger,
  1535.                                     'agent%d-ack' % aa: False,
  1536.                                     'agent%d-hp-ink' % aa: False,
  1537.                                     'agent%d-health' % aa: agent_health,
  1538.                                     'agent%d-dvc' % aa: 0,
  1539.                                     'agent%d-virgin' % aa: False,
  1540.                                     'agent%d-desc' % aa: agent_desc,
  1541.                                     'agent%d-id' % aa: 0,
  1542.                                     'agent%d-health-desc' % aa: agent_health_desc })
  1543.                         aa += 1
  1544.                     else:
  1545.                         log.debug('Not found: %d' % a)
  1546.                     a += 1
  1547.             
  1548.         else:
  1549.             r_value = 0
  1550.             if r_type > 0 and self.r_values is not None:
  1551.                 r_value = self.r_values[0]
  1552.             
  1553.             if r_value > 0 and self.mq.get('r%d-agent1-kind', 0) == 0:
  1554.                 r_value = 0
  1555.             
  1556.             a = 1
  1557.             while True:
  1558.                 mq_agent_kind = self.mq.get('r%d-agent%d-kind' % (r_value, a), 0)
  1559.                 if mq_agent_kind == 0:
  1560.                     break
  1561.                 
  1562.                 mq_agent_type = self.mq.get('r%d-agent%d-type' % (r_value, a), 0)
  1563.                 mq_agent_sku = self.mq.get('r%d-agent%d-sku' % (r_value, a), '')
  1564.                 query = 'agent_%s_%s' % (AGENT_types.get(mq_agent_type, 'unknown'), AGENT_kinds.get(mq_agent_kind, 'unknown'))
  1565.                 agent_desc = self.queryString(query)
  1566.                 self.dq.update({
  1567.                     'agent%d-kind' % a: mq_agent_kind,
  1568.                     'agent%d-type' % a: mq_agent_type,
  1569.                     'agent%d-known' % a: False,
  1570.                     'agent%d-sku' % a: mq_agent_sku,
  1571.                     'agent%d-level' % a: 0,
  1572.                     'agent%d-level-trigger' % a: AGENT_LEVEL_TRIGGER_ALMOST_DEFINITELY_OUT,
  1573.                     'agent%d-ack' % a: False,
  1574.                     'agent%d-hp-ink' % a: False,
  1575.                     'agent%d-health' % a: AGENT_HEALTH_MISINSTALLED,
  1576.                     'agent%d-dvc' % a: 0,
  1577.                     'agent%d-virgin' % a: False,
  1578.                     'agent%d-health-desc' % a: self.queryString('agent_health_unknown'),
  1579.                     'agent%d-desc' % a: agent_desc,
  1580.                     'agent%d-id' % a: 0 })
  1581.                 a += 1
  1582.         for d in self.dq:
  1583.             self.__dict__[d.replace('-', '_')] = self.dq[d]
  1584.         
  1585.         self.last_event = Event(self.device_uri, '', status_code, prop.username, 0, '', time.time())
  1586.         log.debug(self.dq)
  1587.  
  1588.     
  1589.     def isBusyOrInErrorState(self):
  1590.         
  1591.         try:
  1592.             self.queryDevice(quick = True)
  1593.         except Error:
  1594.             return True
  1595.  
  1596.         return self.error_state in (ERROR_STATE_ERROR, ERROR_STATE_BUSY)
  1597.  
  1598.     
  1599.     def isIdleAndNoError(self):
  1600.         
  1601.         try:
  1602.             self.queryDevice(quick = True)
  1603.         except Error:
  1604.             return False
  1605.  
  1606.         return self.error_state not in (ERROR_STATE_ERROR, ERROR_STATE_BUSY)
  1607.  
  1608.     
  1609.     def getPML(self, oid, desired_int_size = pml.INT_SIZE_INT):
  1610.         channel_id = self.openPML()
  1611.         (result_code, data, typ, pml_result_code) = hpmudext.get_pml(self.device_id, channel_id, pml.PMLToSNMP(oid[0]), oid[1])
  1612.         if pml_result_code > pml.ERROR_MAX_OK:
  1613.             log.debug('PML/SNMP GET %s failed (result code = 0x%x)' % (oid[0], pml_result_code))
  1614.             return (pml_result_code, None)
  1615.         converted_data = pml.ConvertFromPMLDataFormat(data, oid[1], desired_int_size)
  1616.         if log.is_debug():
  1617.             if oid[1] in (pml.TYPE_STRING, pml.TYPE_BINARY):
  1618.                 log.debug('PML/SNMP GET %s (result code = 0x%x) returned:' % (oid[0], pml_result_code))
  1619.                 log.log_data(data)
  1620.             else:
  1621.                 log.debug('PML/SNMP GET %s (result code = 0x%x) returned: %s' % (oid[0], pml_result_code, repr(converted_data)))
  1622.         
  1623.         return (pml_result_code, converted_data)
  1624.  
  1625.     
  1626.     def setPML(self, oid, value):
  1627.         channel_id = self.openPML()
  1628.         value = pml.ConvertToPMLDataFormat(value, oid[1])
  1629.         (result_code, pml_result_code) = hpmudext.set_pml(self.device_id, channel_id, pml.PMLToSNMP(oid[0]), oid[1], value)
  1630.         if log.is_debug():
  1631.             if oid[1] in (pml.TYPE_STRING, pml.TYPE_BINARY):
  1632.                 log.debug('PML/SNMP SET %s (result code = 0x%x) to:' % (oid[0], pml_result_code))
  1633.                 log.log_data(value)
  1634.             else:
  1635.                 log.debug('PML/SNMP SET %s (result code = 0x%x) to: %s' % (oid[0], pml_result_code, repr(value)))
  1636.         
  1637.         return pml_result_code
  1638.  
  1639.     
  1640.     def getDynamicCounter(self, counter, convert_to_int = True):
  1641.         dynamic_counters = self.mq.get('status-dynamic-counters', STATUS_DYNAMIC_COUNTERS_NONE)
  1642.         log.debug('Dynamic counters: %d' % dynamic_counters)
  1643.         if dynamic_counters != STATUS_DYNAMIC_COUNTERS_NONE:
  1644.             if dynamic_counters == STATUS_DYNAMIC_COUNTERS_LIDIL_0_5_4:
  1645.                 self.printData(ldl.buildResetPacket(), direct = True)
  1646.                 self.printData(ldl.buildDynamicCountersPacket(counter), direct = True)
  1647.             else:
  1648.                 self.printData(pcl.buildDynamicCounter(counter), direct = True)
  1649.             (value, tries, times_seen, sleepy_time, max_tries) = (0, 0, 0, 0.1, 5)
  1650.             time.sleep(0.1)
  1651.             while True:
  1652.                 if self.callback:
  1653.                     self.callback()
  1654.                 
  1655.                 sleepy_time += 0.1
  1656.                 tries += 1
  1657.                 time.sleep(sleepy_time)
  1658.                 self.getDeviceID()
  1659.                 if 'CTR' in self.deviceID and pat_dynamic_ctr.search(self.raw_deviceID) is not None:
  1660.                     (dev_counter, value) = parseDynamicCounter(self.deviceID['CTR'], convert_to_int)
  1661.                     if counter == dev_counter:
  1662.                         self.printData(pcl.buildDynamicCounter(0), direct = True)
  1663.                         if not convert_to_int:
  1664.                             value = '#' + value
  1665.                         
  1666.                         return value
  1667.                 
  1668.                 None if tries > max_tries else tries > max_tries
  1669.                 self.printData(pcl.buildDynamicCounter(counter), direct = True)
  1670.         else:
  1671.             raise Error(ERROR_DEVICE_DOES_NOT_SUPPORT_OPERATION)
  1672.         return dynamic_counters != STATUS_DYNAMIC_COUNTERS_NONE
  1673.  
  1674.     
  1675.     def readPrint(self, bytes_to_read, stream = None, timeout = prop.read_timeout, allow_short_read = False):
  1676.         return self._Device__readChannel(self.openPrint, bytes_to_read, stream, timeout, allow_short_read)
  1677.  
  1678.     
  1679.     def readPCard(self, bytes_to_read, stream = None, timeout = prop.read_timeout, allow_short_read = False):
  1680.         return self._Device__readChannel(self.openPCard, bytes_to_read, stream, timeout, allow_short_read)
  1681.  
  1682.     
  1683.     def readFax(self, bytes_to_read, stream = None, timeout = prop.read_timeout, allow_short_read = False):
  1684.         return self._Device__readChannel(self.openFax, bytes_to_read, stream, timeout, allow_short_read)
  1685.  
  1686.     
  1687.     def readCfgUpload(self, bytes_to_read, stream = None, timeout = prop.read_timeout, allow_short_read = False):
  1688.         return self._Device__readChannel(self.openCfgUpload, bytes_to_read, stream, timeout, allow_short_read)
  1689.  
  1690.     
  1691.     def readEWS(self, bytes_to_read, stream = None, timeout = prop.read_timeout, allow_short_read = True):
  1692.         return self._Device__readChannel(self.openEWS, bytes_to_read, stream, timeout, allow_short_read)
  1693.  
  1694.     
  1695.     def readSoapFax(self, bytes_to_read, stream = None, timeout = prop.read_timeout, allow_short_read = True):
  1696.         return self._Device__readChannel(self.openSoapFax, bytes_to_read, stream, timeout, allow_short_read)
  1697.  
  1698.     
  1699.     def readWifiConfig(self, bytes_to_read, stream = None, timeout = prop.read_timeout, allow_short_read = True):
  1700.         return self._Device__readChannel(self.openWifiConfig, bytes_to_read, stream, timeout, allow_short_read)
  1701.  
  1702.     
  1703.     def __readChannel(self, opener, bytes_to_read, stream = None, timeout = prop.read_timeout, allow_short_read = False):
  1704.         channel_id = opener()
  1705.         log.debug('Reading channel %d (device-id=%d, bytes_to_read=%d, allow_short=%s, timeout=%d)...' % (channel_id, self.device_id, bytes_to_read, allow_short_read, timeout))
  1706.         num_bytes = 0
  1707.         if stream is None:
  1708.             buffer = ''
  1709.         
  1710.         while True:
  1711.             (result_code, data) = hpmudext.read_channel(self.device_id, channel_id, bytes_to_read, timeout)
  1712.             log.debug('Result code=%d' % result_code)
  1713.             l = len(data)
  1714.             if result_code == hpmudext.HPMUD_R_IO_TIMEOUT:
  1715.                 log.debug('I/O timeout')
  1716.                 break
  1717.             
  1718.             if result_code != hpmudext.HPMUD_R_OK:
  1719.                 log.error('Channel read error')
  1720.                 raise Error(ERROR_DEVICE_IO_ERROR)
  1721.             result_code != hpmudext.HPMUD_R_OK
  1722.             if not l:
  1723.                 log.debug('End of data')
  1724.                 break
  1725.             
  1726.             if stream is None:
  1727.                 buffer = ''.join([
  1728.                     buffer,
  1729.                     data])
  1730.             else:
  1731.                 stream.write(data)
  1732.             num_bytes += l
  1733.             if self.callback is not None:
  1734.                 self.callback()
  1735.             
  1736.             if num_bytes == bytes_to_read:
  1737.                 log.debug('Full read complete.')
  1738.                 break
  1739.             
  1740.             if allow_short_read and num_bytes < bytes_to_read:
  1741.                 log.debug('Allowed short read of %d of %d bytes complete.' % (num_bytes, bytes_to_read))
  1742.                 break
  1743.                 continue
  1744.         if stream is None:
  1745.             log.debug('Returned %d total bytes in buffer.' % num_bytes)
  1746.             return buffer
  1747.         log.debug('Saved %d total bytes to stream.' % num_bytes)
  1748.         return num_bytes
  1749.  
  1750.     
  1751.     def writePrint(self, data):
  1752.         return self._Device__writeChannel(self.openPrint, data)
  1753.  
  1754.     
  1755.     def writePCard(self, data):
  1756.         return self._Device__writeChannel(self.openPCard, data)
  1757.  
  1758.     
  1759.     def writeFax(self, data):
  1760.         return self._Device__writeChannel(self.openFax, data)
  1761.  
  1762.     
  1763.     def writeEWS(self, data):
  1764.         return self._Device__writeChannel(self.openEWS, data)
  1765.  
  1766.     
  1767.     def writeCfgDownload(self, data):
  1768.         return self._Device__writeChannel(self.openCfgDownload, data)
  1769.  
  1770.     
  1771.     def writeSoapFax(self, data):
  1772.         return self._Device__writeChannel(self.openSoapFax, data)
  1773.  
  1774.     
  1775.     def writeWifiConfig(self, data):
  1776.         return self._Device__writeChannel(self.openWifiConfig, data)
  1777.  
  1778.     
  1779.     def __writeChannel(self, opener, data):
  1780.         channel_id = opener()
  1781.         buffer = data
  1782.         bytes_out = 0
  1783.         total_bytes_to_write = len(data)
  1784.         log.debug('Writing %d bytes to channel %d (device-id=%d)...' % (total_bytes_to_write, channel_id, self.device_id))
  1785.         while len(buffer) > 0:
  1786.             (result_code, bytes_written) = hpmudext.write_channel(self.device_id, channel_id, buffer[:prop.max_message_len])
  1787.             log.debug('Result code=%d' % result_code)
  1788.             if result_code != hpmudext.HPMUD_R_OK:
  1789.                 log.error('Channel write error')
  1790.                 raise Error(ERROR_DEVICE_IO_ERROR)
  1791.             result_code != hpmudext.HPMUD_R_OK
  1792.             buffer = buffer[prop.max_message_len:]
  1793.             bytes_out += bytes_written
  1794.             if self.callback is not None:
  1795.                 self.callback()
  1796.                 continue
  1797.         if total_bytes_to_write != bytes_out:
  1798.             raise Error(ERROR_DEVICE_IO_ERROR)
  1799.         total_bytes_to_write != bytes_out
  1800.         return bytes_out
  1801.  
  1802.     
  1803.     def writeEmbeddedPML(self, oid, value, style = 1, direct = True):
  1804.         if style == 1:
  1805.             func = pcl.buildEmbeddedPML2
  1806.         else:
  1807.             func = pcl.buildEmbeddedPML
  1808.         data = func(pcl.buildPCLCmd('&', 'b', 'W', pml.buildEmbeddedPMLSetPacket(oid[0], value, oid[1])))
  1809.         log.log_data(data)
  1810.         self.printData(data, direct = direct, raw = True)
  1811.  
  1812.     
  1813.     def printGzipFile(self, file_name, printer_name = None, direct = False, raw = True, remove = False):
  1814.         return self.printFile(file_name, printer_name, direct, raw, remove)
  1815.  
  1816.     
  1817.     def printParsedGzipPostscript(self, print_file, printer_name = None):
  1818.         
  1819.         try:
  1820.             os.stat(print_file)
  1821.         except OSError:
  1822.             log.error('File not found: %s' % print_file)
  1823.             return None
  1824.  
  1825.         (temp_file_fd, temp_file_name) = utils.make_temp_file()
  1826.         f = gzip.open(print_file, 'r')
  1827.         x = f.readline()
  1828.         while not x.startswith('%PY_BEGIN'):
  1829.             os.write(temp_file_fd, x)
  1830.             x = f.readline()
  1831.         sub_lines = []
  1832.         x = f.readline()
  1833.         while not x.startswith('%PY_END'):
  1834.             sub_lines.append(x)
  1835.             x = f.readline()
  1836.         SUBS = {
  1837.             'VERSION': prop.version,
  1838.             'MODEL': self.model_ui,
  1839.             'URI': self.device_uri,
  1840.             'BUS': self.bus,
  1841.             'SERIAL': self.serial,
  1842.             'IP': self.host,
  1843.             'PORT': self.port,
  1844.             'DEVNODE': self.dev_file }
  1845.         if self.bus == 'net':
  1846.             SUBS['DEVNODE'] = 'n/a'
  1847.         else:
  1848.             SUBS['IP'] = 'n/a'
  1849.             SUBS['PORT'] = 'n/a'
  1850.         for s in sub_lines:
  1851.             os.write(temp_file_fd, s % SUBS)
  1852.         
  1853.         os.write(temp_file_fd, f.read())
  1854.         f.close()
  1855.         os.close(temp_file_fd)
  1856.         self.printFile(temp_file_name, printer_name, direct = False, raw = False, remove = True)
  1857.  
  1858.     
  1859.     def printFile(self, file_name, printer_name = None, direct = False, raw = True, remove = False):
  1860.         is_gzip = os.path.splitext(file_name)[-1].lower() == '.gz'
  1861.         if printer_name is None:
  1862.             printer_name = self.first_cups_printer
  1863.             if not printer_name:
  1864.                 raise Error(ERROR_NO_CUPS_QUEUE_FOUND_FOR_DEVICE)
  1865.             printer_name
  1866.         
  1867.         log.debug("Printing file '%s' to queue '%s' (gzip=%s, direct=%s, raw=%s, remove=%s)" % (file_name, printer_name, is_gzip, direct, raw, remove))
  1868.         if direct:
  1869.             if is_gzip:
  1870.                 self.writePrint(gzip.open(file_name, 'r').read())
  1871.             else:
  1872.                 self.writePrint(file(file_name, 'r').read())
  1873.         elif not utils.which('lpr'):
  1874.             lp_opt = ''
  1875.             if raw:
  1876.                 lp_opt = '-oraw'
  1877.             
  1878.             if is_gzip:
  1879.                 c = 'gunzip -c %s | lp -c -d%s %s' % (file_name, printer_name, lp_opt)
  1880.             else:
  1881.                 c = 'lp -c -d%s %s %s' % (printer_name, lp_opt, file_name)
  1882.             log.debug(c)
  1883.             exit_code = os.system(c)
  1884.             if exit_code != 0:
  1885.                 log.error('Print command failed with exit code %d!' % exit_code)
  1886.             
  1887.             if remove:
  1888.                 os.remove(file_name)
  1889.             
  1890.         else:
  1891.             (raw_str, rem_str) = ('', '')
  1892.             if raw:
  1893.                 raw_str = '-o raw'
  1894.             
  1895.             if remove:
  1896.                 rem_str = '-r'
  1897.             
  1898.             if is_gzip:
  1899.                 c = 'gunzip -c %s | lpr %s %s -P%s' % (file_name, raw_str, rem_str, printer_name)
  1900.             else:
  1901.                 c = 'lpr -P%s %s %s %s' % (printer_name, raw_str, rem_str, file_name)
  1902.             log.debug(c)
  1903.             exit_code = os.system(c)
  1904.             if exit_code != 0:
  1905.                 log.error('Print command failed with exit code %d!' % exit_code)
  1906.             
  1907.  
  1908.     
  1909.     def printTestPage(self, printer_name = None):
  1910.         return self.printParsedGzipPostscript(os.path.join(prop.home_dir, 'data', 'ps', 'testpage.ps.gz'), printer_name)
  1911.  
  1912.     
  1913.     def printData(self, data, printer_name = None, direct = True, raw = True):
  1914.         if direct:
  1915.             self.writePrint(data)
  1916.         else:
  1917.             (temp_file_fd, temp_file_name) = utils.make_temp_file()
  1918.             os.write(temp_file_fd, data)
  1919.             os.close(temp_file_fd)
  1920.             self.printFile(temp_file_name, printer_name, False, raw, remove = True)
  1921.  
  1922.     
  1923.     def cancelJob(self, jobid):
  1924.         cups.cancelJob(jobid)
  1925.         self.error_code = STATUS_PRINTER_CANCELING
  1926.         self.sendEvent(self.error_code)
  1927.  
  1928.     
  1929.     def queryHistory(self):
  1930.         result = []
  1931.         if self.dbus_avail:
  1932.             
  1933.             try:
  1934.                 (device_uri, history) = self.service.GetHistory(self.device_uri)
  1935.             except dbus.exceptions.DBusException:
  1936.                 e = None
  1937.                 log.error('dbus call to GetHistory() failed.')
  1938.                 return []
  1939.  
  1940.             history.reverse()
  1941.             for h in history:
  1942.                 result.append(Event(*tuple(h)))
  1943.             
  1944.             
  1945.             try:
  1946.                 self.error_code = result[0].event_code
  1947.             except IndexError:
  1948.                 self.error_code = STATUS_UNKNOWN
  1949.  
  1950.             self.error_state = STATUS_TO_ERROR_STATE_MAP.get(self.error_code, ERROR_STATE_CLEAR)
  1951.         else:
  1952.             self.error_code = STATUS_UNKNOWN
  1953.             self.error_state = ERROR_STATE_CLEAR
  1954.         self.hist = result
  1955.         return result
  1956.  
  1957.     
  1958.     def getEWSUrl(self, url, stream):
  1959.         
  1960.         try:
  1961.             if self.is_local:
  1962.                 url2 = '%s&loc=%s' % (self.device_uri.replace('hpfax:', 'hp:'), url)
  1963.                 data = self
  1964.             else:
  1965.                 url2 = 'http://%s%s' % (self.host, url)
  1966.                 if self.zc:
  1967.                     (status, ip) = hpmudext.get_zc_ip_address(self.zc)
  1968.                     if status == hpmudext.HPMUD_R_OK:
  1969.                         url2 = 'http://%s%s' % (ip, url)
  1970.                     
  1971.                 
  1972.                 data = None
  1973.             log.debug('Opening: %s' % url2)
  1974.             opener = LocalOpener({ })
  1975.             
  1976.             try:
  1977.                 f = opener.open(url2, data)
  1978.             except Error:
  1979.                 log.error('Status read failed: %s' % url2)
  1980.                 stream.seek(0)
  1981.                 stream.truncate()
  1982.  
  1983.             
  1984.             try:
  1985.                 stream.write(f.read())
  1986.             finally:
  1987.                 f.close()
  1988.  
  1989.         finally:
  1990.             self.closeEWS()
  1991.  
  1992.  
  1993.     
  1994.     def downloadFirmware(self, usb_bus_id = None, usb_device_id = None):
  1995.         ok = False
  1996.         filename = os.path.join(prop.data_dir, 'firmware', self.model.lower() + '.fw.gz')
  1997.         log.debug(filename)
  1998.         if os.path.exists(filename):
  1999.             log.debug("Downloading firmware file '%s'..." % filename)
  2000.             
  2001.             try:
  2002.                 self.openPrint()
  2003.                 bytes_written = self.writePrint(gzip.open(filename).read())
  2004.                 log.debug('%s bytes downloaded.' % utils.commafy(bytes_written))
  2005.                 self.closePrint()
  2006.                 ok = True
  2007.                 log.debug('OK')
  2008.             except Error:
  2009.                 e = None
  2010.                 log.error('An error occured: %s' % e.msg)
  2011.             except:
  2012.                 None<EXCEPTION MATCH>Error
  2013.             
  2014.  
  2015.         None<EXCEPTION MATCH>Error
  2016.         log.error("Firmware file '%s' not found." % filename)
  2017.         return ok
  2018.  
  2019.  
  2020.  
  2021. class xStringIO(StringIO.StringIO):
  2022.     
  2023.     def makefile(self, x, y):
  2024.         return self
  2025.  
  2026.  
  2027.  
  2028. class LocalOpener(urllib.URLopener):
  2029.     
  2030.     def open_hp(self, url, dev):
  2031.         log.debug('open_hp(%s)' % url)
  2032.         match_obj = http_pat_url.search(url)
  2033.         if not match_obj.group(1):
  2034.             pass
  2035.         bus = ''
  2036.         if not match_obj.group(2):
  2037.             pass
  2038.         model = ''
  2039.         if not match_obj.group(3):
  2040.             pass
  2041.         serial = ''
  2042.         if not match_obj.group(4):
  2043.             pass
  2044.         device = ''
  2045.         if not match_obj.group(5):
  2046.             pass
  2047.         loc = ''
  2048.         dev.openEWS()
  2049.         dev.writeEWS('GET %s HTTP/1.0\nContent-Length:0\nHost:localhost\nUser-Agent:hplip\n\n' % loc)
  2050.         reply = xStringIO()
  2051.         while dev.readEWS(8192, reply, timeout = 1):
  2052.             pass
  2053.         reply.seek(0)
  2054.         log.log_data(reply.getvalue())
  2055.         response = httplib.HTTPResponse(reply)
  2056.         response.begin()
  2057.         if response.status != httplib.OK:
  2058.             raise Error(ERROR_DEVICE_STATUS_NOT_AVAILABLE)
  2059.         response.status != httplib.OK
  2060.         return response.fp
  2061.  
  2062.  
  2063.